﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

using NUnit.Framework;

using Working.Domínio.Vendas;
using Working.Domínio.Produtos;
using Working.Domínio.Pagamentos;


namespace Working.Domínio.Vendas.Teste
{
    [TestFixture]
    public class TesteVenda
    {
        [Test]
        public void TestaConstrutor()
        {
            DateTime horaInícioDoTeste = DateTime.Today;

            Venda venda = new Venda();            
            Assert.LessOrEqual(horaInícioDoTeste, venda.DataInícioDaVenda);
            Assert.AreNotEqual(DateTime.MinValue, venda.DataInícioDaVenda);
            Assert.AreEqual(DateTime.MinValue, venda.DataFimDaVenda);
            Assert.IsNotNull(venda.Itens);
            Assert.IsEmpty(venda.Itens);
            Assert.IsNull(venda.Pagamento);
            Assert.IsFalse(venda.EstáCompleta);
            Assert.IsFalse(venda.EstáFinalizada);
        }

        [Test]
        public void TestaPropriedades()
        {
            Venda venda = new Venda();

            DateTime dataInícioDaVendaEsperada = new DateTime(1999, 03, 11);
            DateTime dataFimDaVendaEsperada = new DateTime(1999, 03, 11);
            TimeSpan duraçãoDaVenda = new TimeSpan(1, 30, 15);
            dataFimDaVendaEsperada = dataFimDaVendaEsperada.Add(duraçãoDaVenda);

            venda.DataInícioDaVenda = dataInícioDaVendaEsperada;
            venda.DataFimDaVenda = dataFimDaVendaEsperada;

            Assert.AreEqual(dataInícioDaVendaEsperada, venda.DataInícioDaVenda);
            Assert.AreEqual(dataFimDaVendaEsperada, venda.DataFimDaVenda);
            Assert.AreEqual(duraçãoDaVenda, venda.Duração);
            Assert.IsNull(venda.Pagamento);
            Assert.IsFalse(venda.EstáCompleta);
            Assert.IsFalse(venda.EstáFinalizada);
        }

        [Test]
        public void TestaAdicionarItem()
        {
            Venda venda = new Venda();

            Produto produto = new Produto();
            produto.Nome = "Working Sales";
            produto.Preço = 2000M;

            int quantidade = 5;

            venda.AdicionarItem(produto, quantidade);
            Assert.IsNotEmpty(venda.Itens);
            Assert.AreEqual(produto, venda.Itens[0].Produto);
            Assert.AreEqual(quantidade, venda.Itens[0].Quantidade);
        }

        [Test]
        [ExpectedException(typeof(ApplicationException))]
        public void TestaAdicionarItemComProdutoNulo()
        {
            Venda venda = new Venda();

            Produto produto = null;
            int quantidade = 1;

            venda.AdicionarItem(produto, quantidade);
        }

        [Test]
        [ExpectedException(typeof(QuantidadeDeItensInválidaException))]
        public void TestaAdicionarItemSemQuantidade()
        {
            Venda venda = new Venda();

            Produto produto = new Produto();
            int quantidade = 0;

            venda.AdicionarItem(produto, quantidade);
        }

        [Test]
        public void TestaAdicionarItemSemParâmetroQuantidade()
        {
            Venda venda = new Venda();
            Produto produto = new Produto();
            int quantidadeDeItens = 1;

            venda.AdicionarItem(produto);
            Assert.AreEqual(quantidadeDeItens, venda.Itens[0].Quantidade);
        }

        [Test]
        [ExpectedException(typeof(QuantidadeDeItensInválidaException))]
        public void TestaAdicionarItemComQuantidadeNegativa()
        {
            Venda venda = new Venda();

            Produto produto = new Produto();
            int quantidade = -1;

            venda.AdicionarItem(produto, quantidade);
        }


        [Test]
        public void TestaTotalSemItens()
        {
            Venda venda = new Venda();
            Assert.AreEqual(0M, venda.Total);
        }

        [Test]
        public void TestaTotalComUmItemEUmaUnidade()
        {
            Venda venda = new Venda();
            decimal valorProduto = 120M;
            int quantidade = 1;

            Produto produto = new Produto();
            produto.Nome = "Camisa do Cruzeiro";
            produto.Preço = valorProduto;

            venda.AdicionarItem(produto, quantidade);
            Assert.AreEqual(valorProduto, venda.Total);
        }

        [Test]
        public void TestaTotalComUmItemEVáriasUnidades()
        {
            Venda venda = new Venda();
            decimal valorProduto = 120M;            
            int quantidade = 8;
            decimal valorVenda = 960M;

            Produto produto = new Produto();
            produto.Nome = "Camisa do Flamengo";
            produto.Preço = valorProduto;

            venda.AdicionarItem(produto, quantidade);
            Assert.AreEqual(valorVenda, venda.Total);
        }

        [Test]
        public void TestaTotalComVáriosItemEUmaUnidade()
        {
            Venda venda = new Venda();            
            decimal valorVenda = 2500M;

            Produto produto1 = new Produto();
            produto1.Nome = "Camisa do Cruzeiro";
            produto1.Preço = 130M;

            Produto produto2 = new Produto();
            produto2.Nome = "Camisa do Flamengo";
            produto2.Preço = 120M;

            Produto produto3 = new Produto();
            produto3.Nome = "Camisa da Seleção";
            produto3.Preço = 200M;

            Produto produto4 = new Produto();
            produto4.Nome = "TV de Plasma";
            produto4.Preço = 1850M;

            Produto produto5 = new Produto();
            produto5.Nome = "Whisky Johnny Walker";
            produto5.Preço = 200M;

            venda.AdicionarItem(produto1);
            venda.AdicionarItem(produto2);
            venda.AdicionarItem(produto3);
            venda.AdicionarItem(produto4);
            venda.AdicionarItem(produto5);
            Assert.AreEqual(valorVenda, venda.Total);
        }

        [Test]
        public void TestaTotalComVáriosItemEVáriasUnidade()
        {
            Venda venda = new Venda();
            decimal valorVenda = 9370M;

            Produto produto1 = new Produto();
            produto1.Nome = "Camisa do Cruzeiro";
            produto1.Preço = 130M;

            Produto produto2 = new Produto();
            produto2.Nome = "Camisa do Flamengo";
            produto2.Preço = 120M;

            Produto produto3 = new Produto();
            produto3.Nome = "Camisa da Seleção";
            produto3.Preço = 200M;

            Produto produto4 = new Produto();
            produto4.Nome = "TV de Plasma";
            produto4.Preço = 1850M;

            Produto produto5 = new Produto();
            produto5.Nome = "Whisky Johnny Walker";
            produto5.Preço = 200M;

            venda.AdicionarItem(produto1, 1);
            venda.AdicionarItem(produto2, 2);
            venda.AdicionarItem(produto3, 3);
            venda.AdicionarItem(produto4, 4);
            venda.AdicionarItem(produto5, 5);
            Assert.AreEqual(valorVenda, venda.Total);
        }

        [Test]
        public void TestaDuraçãoDaVendaFinalizada()
        {
            Venda venda = new Venda();
            TimeSpan tempoDeDuração = new TimeSpan(00, 00, 05);
            venda.DataInícioDaVenda = DateTime.Today;
            venda.DataFimDaVenda = venda.DataInícioDaVenda.Add(tempoDeDuração);

            Assert.AreEqual(tempoDeDuração, venda.Duração); 
        }

        [Test]
        public void TestaDuraçãoDaVendaNãoFinalizada()
        {
            Venda venda = new Venda();
            TimeSpan tempoDeDuração = new TimeSpan(00, 00, 01);
            //Para a execução do teste por 1 segundo 
            Thread.Sleep(Convert.ToInt32(tempoDeDuração.TotalMilliseconds));
            Assert.AreEqual(tempoDeDuração, venda.Duração);
        }

        [Test]
        public void TestaFazerPagamentoEmDinheiro()
        {
            decimal quantiaFornecida = 1200m;
            Venda venda = new Venda();
            venda.FazerPagamento(quantiaFornecida);
            Assert.AreEqual(quantiaFornecida, venda.Pagamento.Quantia);
        }

        [Test]
        [ExpectedException(typeof(QuantiaInválidaException))]
        public void TestaFazerPagamentoEmDinheiroComQuantiaNegativa()
        {
            decimal quantiaFornecida = -100m;
            Venda venda = new Venda();
            venda.FazerPagamento(quantiaFornecida);
        }

        [Test]
        public void TestaFazerPagamentoEmDinheiroComQuantiaZerada()
        {
            decimal quantiaFornecida = 0m;
            Venda venda = new Venda();
            venda.FazerPagamento(quantiaFornecida);
            Assert.AreEqual(quantiaFornecida, venda.Pagamento.Quantia);
            Assert.AreEqual(quantiaFornecida, venda.Saldo());
        }

        [Test]
        public void TestaFazerPagamentoEmDinheiroComTrocoESemItem()
        {
            decimal quantiaFornecida = 100m;
            Venda venda = new Venda();
            venda.FazerPagamento(quantiaFornecida);
            Assert.AreEqual(quantiaFornecida, venda.Pagamento.Quantia);
            Assert.AreEqual(quantiaFornecida, venda.Saldo());
        }

        [Test]
        public void TestaFazerPagamentoEmDinheiroComTrocoEComItem()
        {
            //Produtos da venda
            Produto produto1 = new Produto("0001", "Sapato", 25m);
            Produto produto2 = new Produto("0002", "Meia", 10m);
            Produto produto3 = new Produto("0003", "Mochila", 50m);
            decimal quantiaFornecida = 100m;
            decimal trocoEsperado = 15m;

            Venda venda = new Venda();
            venda.AdicionarItem(produto1);
            venda.AdicionarItem(produto2);
            venda.AdicionarItem(produto3);
            venda.FazerPagamento(quantiaFornecida);

            Assert.AreEqual(quantiaFornecida, venda.Pagamento.Quantia);
            Assert.AreEqual(trocoEsperado, venda.Saldo());
        }

        [Test]
        public void TestaSaldoSemItemDeVendaESemPagamento()
        {
            Venda venda = new Venda();
            Assert.AreEqual(0, venda.Saldo());
        }

        [Test]
        public void TestaSaldoSemItemDeVendaEComPagamento()
        {
            Venda venda = new Venda();
            decimal valorDoPagamento = 100m;
            venda.FazerPagamento(valorDoPagamento);
            Assert.AreEqual(valorDoPagamento, venda.Saldo());
        }

        [Test]
        public void TestaSaldoComUmItemDeVendaESemPagamento()
        {
            decimal valorDoProduto = 100m;
            decimal saldoEsperado = valorDoProduto * -1;
            Produto produto1 = new Produto(new ItemID("0001"), "Produto 1", valorDoProduto);
            
            Venda venda = new Venda();
            venda.AdicionarItem(produto1);

            Assert.AreEqual(saldoEsperado, venda.Saldo());
        }

        [Test]
        public void TestaSaldoComUmItemDeVendaEmQuantidadeESemPagamento()
        {
            int quantidadeDeItens = 5;
            decimal valorDoProduto = 100m;
            decimal saldoEsperado = (valorDoProduto * quantidadeDeItens) * -1;
            Produto produto1 = new Produto(new ItemID("0001"), "Produto 1", valorDoProduto);

            Venda venda = new Venda();
            venda.AdicionarItem(produto1, quantidadeDeItens);

            Assert.AreEqual(saldoEsperado, venda.Saldo());
        }

        [Test]
        public void TestaSaldoComVáriosItemDeVendaESemPagamento()
        {
            decimal valorDoProduto1 = 100m;
            decimal valorDoProduto2 = 250m;
            decimal valorDoProduto3 = .99m;
            decimal saldoEsperado = (valorDoProduto1 + valorDoProduto2 + valorDoProduto3) * -1;

            Produto produto1 = new Produto(new ItemID("0001"), "Produto 1", valorDoProduto1);
            Produto produto2 = new Produto(new ItemID("0002"), "Produto 2", valorDoProduto2);
            Produto produto3 = new Produto(new ItemID("0003"), "Produto 3", valorDoProduto3);

            Venda venda = new Venda();
            venda.AdicionarItem(produto1);
            venda.AdicionarItem(produto2);
            venda.AdicionarItem(produto3);

            Assert.AreEqual(saldoEsperado, venda.Saldo());
        }

        [Test]
        public void TestaSaldoComVáriosItemDeVendaEmQuantidadeESemPagamento()
        {
            //Subtotal do produto 1 será 200.00
            decimal valorDoProduto1 = 100m;
            int quantidadeDeItensProduto1 = 2;

            //Subtotal do produto 1 será 800.00
            decimal valorDoProduto2 = 200m;
            int quantidadeDeItensProduto2 = 4;

            //Subtotal do produto 1 será 900.00
            decimal valorDoProduto3 = 300m;
            int quantidadeDeItensProduto3 = 3;

            decimal saldoEsperado = -1900m;

            Produto produto1 = new Produto(new ItemID("0001"), "Produto 1", valorDoProduto1);
            Produto produto2 = new Produto(new ItemID("0002"), "Produto 2", valorDoProduto2);
            Produto produto3 = new Produto(new ItemID("0003"), "Produto 3", valorDoProduto3);

            Venda venda = new Venda();
            venda.AdicionarItem(produto1, quantidadeDeItensProduto1);
            venda.AdicionarItem(produto2, quantidadeDeItensProduto2);
            venda.AdicionarItem(produto3, quantidadeDeItensProduto3);

            Assert.AreEqual(saldoEsperado, venda.Saldo());
        }

        [Test]
        public void TestaSaldoComUmItemDeVendaEComPagamentoSemTroco()
        {
            decimal valorDoProduto = 100m;
            Produto produto1 = new Produto(new ItemID("0001"), "Produto 1", valorDoProduto);

            Venda venda = new Venda();
            venda.AdicionarItem(produto1);
            venda.FazerPagamento(valorDoProduto);

            Assert.AreEqual(0, venda.Saldo());
        }

        [Test]
        public void TestaSaldoComUmItemDeVendaEComPagamentoComTroco()
        {
            decimal valorDoProduto = 100m;
            decimal valorDoPagamento = 150m;
            decimal troco = 50m;
            Produto produto1 = new Produto(new ItemID("0001"), "Produto 1", valorDoProduto);

            Venda venda = new Venda();
            venda.AdicionarItem(produto1);
            venda.FazerPagamento(valorDoPagamento);

            Assert.AreEqual(troco, venda.Saldo());
        }

        [Test]
        public void TestaSaldoComUmItemDeVendaEComPagamentoInsuficiente()
        {
            decimal valorDoProduto = 100m;
            decimal valorDoPagamento = 50m;
            decimal saldoInsuficiente = -50m;
            Produto produto1 = new Produto(new ItemID("0001"), "Produto 1", valorDoProduto);

            Venda venda = new Venda();
            venda.AdicionarItem(produto1);
            venda.FazerPagamento(valorDoPagamento);

            Assert.AreEqual(saldoInsuficiente, venda.Saldo());
        }

        [Test]
        public void TestaSaldoComUmItemDeVendaEmQuantidadeEComPagamentoSemTroco()
        {
            int quantidadeDeItens = 5;
            decimal valorDoProduto = 100m;
            decimal valorDoPagamento = 500m;

            Produto produto1 = new Produto(new ItemID("0001"), "Produto 1", valorDoProduto);

            Venda venda = new Venda();
            venda.AdicionarItem(produto1, quantidadeDeItens);
            venda.FazerPagamento(valorDoPagamento);

            Assert.AreEqual(0, venda.Saldo());
        }

        [Test]
        public void TestaSaldoComUmItemDeVendaEmQuantidadeEComPagamentoComTroco()
        {
            int quantidadeDeItens = 4;
            decimal valorDoProduto = 150m;
            decimal valorDoPagamento = 700m;
            decimal troco = 100m;
            Produto produto1 = new Produto(new ItemID("0001"), "Produto 1", valorDoProduto);

            Venda venda = new Venda();
            venda.AdicionarItem(produto1, quantidadeDeItens);
            venda.FazerPagamento(valorDoPagamento);

            Assert.AreEqual(troco, venda.Saldo());
        }

        [Test]
        public void TestaSaldoComUmItemDeVendaEmQuantidadeEComPagamentoInsuficiente()
        {
            int quantidadeDeItens = 5;
            decimal valorDoProduto = 200m;
            decimal valorDoPagamento = 800m;
            decimal saldoInsuficiente = -200m;
            Produto produto1 = new Produto(new ItemID("0001"), "Produto 1", valorDoProduto);

            Venda venda = new Venda();
            venda.AdicionarItem(produto1, quantidadeDeItens);
            venda.FazerPagamento(valorDoPagamento);

            Assert.AreEqual(saldoInsuficiente, venda.Saldo());
        }


        [Test]
        public void TestaSaldoComVáriosItemDeVendaEComPagamentoSemTroco()
        {
            decimal valorDoProduto1 = 100m;
            decimal valorDoProduto2 = 250m;
            decimal valorDoProduto3 = .99m;
            decimal valorDoPagamento = 350.99m;

            Produto produto1 = new Produto(new ItemID("0001"), "Produto 1", valorDoProduto1);
            Produto produto2 = new Produto(new ItemID("0002"), "Produto 2", valorDoProduto2);
            Produto produto3 = new Produto(new ItemID("0003"), "Produto 3", valorDoProduto3);

            Venda venda = new Venda();
            venda.AdicionarItem(produto1);
            venda.AdicionarItem(produto2);
            venda.AdicionarItem(produto3);
            venda.FazerPagamento(valorDoPagamento);

            Assert.AreEqual(0, venda.Saldo());
        }

        [Test]
        public void TestaSaldoComVáriosItemDeVendaEComPagamentoComTroco()
        {
            decimal valorDoProduto1 = 100m;
            decimal valorDoProduto2 = 250m;
            decimal valorDoProduto3 = .99m;
            decimal valorDoPagamento = 400m;
            decimal troco = 49.01m;

            Produto produto1 = new Produto(new ItemID("0001"), "Produto 1", valorDoProduto1);
            Produto produto2 = new Produto(new ItemID("0002"), "Produto 2", valorDoProduto2);
            Produto produto3 = new Produto(new ItemID("0003"), "Produto 3", valorDoProduto3);

            Venda venda = new Venda();
            venda.AdicionarItem(produto1);
            venda.AdicionarItem(produto2);
            venda.AdicionarItem(produto3);
            venda.FazerPagamento(valorDoPagamento);

            Assert.AreEqual(troco, venda.Saldo());
        }

        [Test]
        public void TestaSaldoComVáriosItemDeVendaEComPagamentoInsuficiente()
        {
            decimal valorDoProduto1 = 100m;
            decimal valorDoProduto2 = 250m;
            decimal valorDoProduto3 = .99m;
            decimal valorDoPagamento = 250m;
            decimal saldoInsuficiente = -100.99m;

            Produto produto1 = new Produto(new ItemID("0001"), "Produto 1", valorDoProduto1);
            Produto produto2 = new Produto(new ItemID("0002"), "Produto 2", valorDoProduto2);
            Produto produto3 = new Produto(new ItemID("0003"), "Produto 3", valorDoProduto3);

            Venda venda = new Venda();
            venda.AdicionarItem(produto1);
            venda.AdicionarItem(produto2);
            venda.AdicionarItem(produto3);
            venda.FazerPagamento(valorDoPagamento);

            Assert.AreEqual(saldoInsuficiente, venda.Saldo());
        }

        [Test]
        public void TestaSaldoComVáriosItemDeVendaEmQuantidadeEComPagamentoSemTroco()
        {
            //Subtotal do produto 1 será 200.00
            decimal valorDoProduto1 = 100m;
            int quantidadeDeItensProduto1 = 2;

            //Subtotal do produto 1 será 800.00
            decimal valorDoProduto2 = 200m;
            int quantidadeDeItensProduto2 = 4;

            //Subtotal do produto 1 será 900.00
            decimal valorDoProduto3 = 300m;
            int quantidadeDeItensProduto3 = 3;

            decimal valorDoPagamento = 1900m;

            Produto produto1 = new Produto(new ItemID("0001"), "Produto 1", valorDoProduto1);
            Produto produto2 = new Produto(new ItemID("0002"), "Produto 2", valorDoProduto2);
            Produto produto3 = new Produto(new ItemID("0003"), "Produto 3", valorDoProduto3);

            Venda venda = new Venda();
            venda.AdicionarItem(produto1, quantidadeDeItensProduto1);
            venda.AdicionarItem(produto2, quantidadeDeItensProduto2);
            venda.AdicionarItem(produto3, quantidadeDeItensProduto3);
            venda.FazerPagamento(valorDoPagamento);

            Assert.AreEqual(0, venda.Saldo());
        }

        [Test]
        public void TestaSaldoComVáriosItemDeVendaEmQuantidadeEComPagamentoComTroco()
        {
            //Subtotal do produto 1 será 100.00
            decimal valorDoProduto1 = 50m;
            int quantidadeDeItensProduto1 = 2;

            //Subtotal do produto 1 será 6.00
            decimal valorDoProduto2 = 1.50m;
            int quantidadeDeItensProduto2 = 4;

            //Subtotal do produto 1 será 3.00
            decimal valorDoProduto3 = 1m;
            int quantidadeDeItensProduto3 = 3;

            decimal valorDoPagamento = 110m;
            decimal troco = 1m;

            Produto produto1 = new Produto(new ItemID("0001"), "Produto 1", valorDoProduto1);
            Produto produto2 = new Produto(new ItemID("0002"), "Produto 2", valorDoProduto2);
            Produto produto3 = new Produto(new ItemID("0003"), "Produto 3", valorDoProduto3);

            Venda venda = new Venda();
            venda.AdicionarItem(produto1, quantidadeDeItensProduto1);
            venda.AdicionarItem(produto2, quantidadeDeItensProduto2);
            venda.AdicionarItem(produto3, quantidadeDeItensProduto3);
            venda.FazerPagamento(valorDoPagamento);

            Assert.AreEqual(troco, venda.Saldo());
        }

        [Test]
        public void TestaSaldoComVáriosItemDeVendaEmQuantidadeEComPagamentoInsuficiente()
        {
            //Subtotal do produto 1 será 200.00
            decimal valorDoProduto1 = 100m;
            int quantidadeDeItensProduto1 = 2;

            //Subtotal do produto 2 será 750.00
            decimal valorDoProduto2 = 250m;
            int quantidadeDeItensProduto2 = 3;

            //Subtotal do produto 3 será 200.00
            decimal valorDoProduto3 = 50m;
            int quantidadeDeItensProduto3 = 4;

            decimal valorDoPagamento = 1000m;
            decimal saldoInsuficiente = -150m;

            Produto produto1 = new Produto(new ItemID("0001"), "Produto 1", valorDoProduto1);
            Produto produto2 = new Produto(new ItemID("0002"), "Produto 2", valorDoProduto2);
            Produto produto3 = new Produto(new ItemID("0003"), "Produto 3", valorDoProduto3);

            Venda venda = new Venda();
            venda.AdicionarItem(produto1, quantidadeDeItensProduto1);
            venda.AdicionarItem(produto2, quantidadeDeItensProduto2);
            venda.AdicionarItem(produto3, quantidadeDeItensProduto3);
            venda.FazerPagamento(valorDoPagamento);

            Assert.AreEqual(saldoInsuficiente, venda.Saldo());
        }

        [Test]
        [ExpectedException(typeof(NenhumItemAdicionadoAVendaException))]
        public void TestaFinalizarVendaSemProdutos()
        {
            Venda venda = new Venda();
            venda.FazerPagamento(0m);
            venda.Finalizar();
        }

        [Test]
        [ExpectedException(typeof(PagamentoDaVendaNãoRealizadoException))]
        public void TestaFinalizarVendaComProdutos()
        {
            Venda venda = new Venda();
            venda.AdicionarItem(new Produto("001", "Produto de teste", 50m));
            venda.Finalizar();
        }

        [Test]
        [ExpectedException(typeof(PagamentoDaVendaNãoRealizadoException))]
        public void TestaFinalizarVendaComPagamentoInsuficiente()
        {
            Venda venda = new Venda();
            venda.AdicionarItem(new Produto("001", "Produto de teste", 100m));
            venda.FazerPagamento(50m);
            venda.Finalizar();
        }

        [Test]
        public void TestaFinalizarVendaVerificandoIntegridade()
        {
            Venda venda = new Venda();
            venda.AdicionarItem(new Produto("001", "Produto de teste", 100m));
            venda.FazerPagamento(50m);

            try { venda.Finalizar(); }
            catch (PagamentoDaVendaNãoRealizadoException) { }

            Assert.AreEqual(DateTime.MinValue, venda.DataFimDaVenda);
            Assert.IsFalse(venda.EstáFinalizada);
        }

        [Test]
        public void TestaFinalizarVendaComPagamento()
        {
            decimal valorDoProduto = 100m;
            Venda venda = new Venda();
            venda.AdicionarItem(new Produto("001", "Produto de teste", valorDoProduto));
            venda.FazerPagamento(valorDoProduto);
            //Mantem a precisão em até segundos
            DateTime dataDeFimDaVenda = new DateTime(DateTime.Now.Year, DateTime.Now.Month,
                DateTime.Now.Day, DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second);
                
            venda.Finalizar();

            Assert.AreEqual(dataDeFimDaVenda, venda.DataFimDaVenda);
            Assert.IsTrue(venda.EstáCompleta);
            Assert.IsTrue(venda.EstáFinalizada);
        }

        [Test]
        public void TestaFinalizarVendaSemChamarOCompletar()
        {
            decimal valorDoProduto = 100m;
            Venda venda = new Venda();
            venda.AdicionarItem(new Produto("001", "Produto de teste", valorDoProduto));
            venda.FazerPagamento(valorDoProduto);
            //Mantem a precisão em até segundos
            DateTime dataDeFimDaVenda = new DateTime(DateTime.Now.Year, DateTime.Now.Month,
                DateTime.Now.Day, DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second);

            venda.Finalizar();
            Assert.IsTrue(venda.EstáCompleta);
        }

    }
}
